home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 051-060 / amok52 / gadgeted / txt / arp.def next >
Text File  |  1993-11-04  |  26KB  |  601 lines
  1. (*---------------------------------------------------------------------------
  2.   :Program.    ARP.def
  3.   :Author.     M2 implementation by Fridtjof Siebert
  4.   :Address.    Nobileweg 67, D-7-Stgt-40
  5.   :Shortcut.   [fbs]
  6.   :Version.    1.0 (ARP version 34)
  7.   :Date.       14-Jan-88
  8.   :Copyright.  PD
  9.   :Language.   Modula-II
  10.   :Translator. M2Amiga v3.2d
  11.   :History.    30-Dec-88 v0.1 created for ARP1.0          [fbs]
  12.   :History.    14-Jan-88 v1.0 implementation for ARP1.1   [fbs]
  13.   :Contents.   Library Modul for arp.library.
  14.   :Remark.     Contact me if your find errors. I wasn't able to all of it!
  15.   :Remark.     Thanx to Martin Taillefer for his Benchmark ARP-code
  16. ---------------------------------------------------------------------------*)
  17.  
  18. DEFINITION MODULE ARP {"arp.library",34};
  19.  
  20. FROM SYSTEM    IMPORT ADDRESS, LONGSET, SHIFT, BPTR;
  21. FROM Dos       IMPORT DosLibrary, FileInfoBlock, FileInfoBlockPtr,
  22.                       FileHandlePtr, FileLockPtr, ProcessPtr, DosPacketPtr,
  23.                       DatePtr, BSTR, DeviceList, Date, InfoDataPtr;
  24. FROM Exec      IMPORT UByte, Byte, MinList, MinNode, MsgPortPtr, MemReqSet,
  25.                       SignalSemaphore, TaskPtr, Node, Library, Message;
  26. FROM Graphics  IMPORT GfxBasePtr;
  27. FROM Intuition IMPORT IntuitionBase, WindowPtr;
  28.  
  29. (*------  Some Pointers:  ------*)
  30.  
  31. TYPE
  32.   STRPTR = ADDRESS;         (* POINTER TO ARRAY OF CHAR, used for clarity *)
  33.   DeviceListPtr = POINTER TO DeviceList; (* can't be imported from DOS *)
  34.  
  35. (*------  Types needed for template:  ------*)
  36.  
  37.   StrArrayPtr = POINTER TO ARRAY [0..1000] OF STRPTR;
  38.   (* StrArrayPtr is a pointer to an array of pointers to strings *)
  39.  
  40.   WBArgPtr = POINTER TO WBArg;
  41.   WBArg = RECORD
  42.     lock: FileLockPtr;      (* a lock descriptor *)
  43.     str : STRPTR;           (* a string relative to that lock *)
  44.   END;
  45.  
  46.   CLIArgPtr = POINTER TO CLIArg;
  47.   CLIArg = RECORD
  48.     CASE : CARDINAL OF
  49.       0: bool: BOOLEAN;     |
  50.       1: long: LONGINT;     |
  51.       2: str: STRPTR;       |
  52.       3: array: StrArrayPtr;|
  53.     END;
  54.   END;
  55.  
  56. (*------  Library Stuff:  ------*)
  57.  
  58. (* use Wildcards/escapes like rest of world or like current dos: *)
  59.  
  60.   ArpFlags = (wildWorld,wildBCPL);
  61.   ArpFlagSet = SET OF ArpFlags;
  62.  
  63.   EnvLibPtr  = POINTER TO EnvLib;
  64.   ArpBasePtr = POINTER TO ArpBase;
  65.   ArpBase = RECORD
  66.     libNode: Library;         (* Standard library node *)
  67.     segList: BPTR;            (* Pointer to segment list of loaded library *)
  68.     flags: Byte;              (* Not used, yet! *)
  69.     escChar: CHAR;            (* Character used for ESCaping *)
  70.     abreserved: LONGCARD;     (* ArpLib's use only!! *)
  71.     envBase: EnvLibPtr;       (* ptr to environment                   *)
  72.     dosBase: POINTER TO DosLibrary;
  73.     gfxBase: GfxBasePtr;
  74.     intuiBase: POINTER TO IntuitionBase;
  75.     resLists: MinList;
  76.     residentPrgList: ADDRESS; (* Resident Programs.   *)
  77.     resPrgProtection: SignalSemaphore; (* Protection for above *)
  78.   END;
  79.  
  80.   EnvLib = RECORD
  81.     libNode: Library;
  82.     space: ADDRESS;
  83.     size: LONGCARD;
  84.     arpBase: ArpBasePtr;
  85.   END;
  86.  
  87. (* library constants: *)
  88.  
  89. CONST
  90.   arpname = 'arp.library';
  91.   arpversion = 34;
  92.  
  93. (*------  ARP Alert Numbers:  ------*)
  94.  
  95.   aoArpLib = 8036H; (* Alert Object *)
  96.  
  97.   (* Alerts ARP can return *)
  98.   anArpLib       = 03600000H;
  99.   anArpNoMem     = 03610000H;    (* ArpLibrary out of memory              *)
  100.   anArpInputMem  = 03610002H;    (* No memory for input buffer            *)
  101.   anArpNoMakeEnv = 83610003H;    (* No memory for Environment library     *)
  102.  
  103.   anArpNoDOS     = 83630001H;    (* Can't Open DOS library                *)
  104.   anArpNoGfx     = 83630002H;    (* Can't open Graphics library           *)
  105.   anArpNoIntuit  = 83630003H;    (* Can't open Intuition library          *)
  106.   anBadPackBlues = 83640000H;    (* Bad packet returned to SendPacket()   *)
  107.   anZombie       = 83600003H;    (* Zombie roaming around system          *)
  108.  
  109.   anArpScattered = 83600002H;    (* Scatter loading not allowed           *)
  110.  
  111. (*------  Return codes from Assign() and CompareLock(): ------*)
  112.  
  113. TYPE
  114.   AssignRes = (assignOK,assignNoDev,assignFatal,assignCancel);
  115.   LockComp  = (equal,equalVolume,difVol1,difVol2);
  116.  
  117. CONST
  118.   maxInputBuf = 256;  (* size of buffer needed for ReadLine() *)
  119.  
  120. (*------  Input structure for File Requester  ------*)
  121.  
  122.   fChars = 32;
  123.   dSize  = 33;
  124.   frFirstGadg = 7680H;
  125.  
  126. TYPE
  127.   FileName = ARRAY[0..fChars] OF CHAR;
  128.   DirName  = ARRAY[0..dSize] OF CHAR;
  129.   FileNamePtr = POINTER TO FileName;
  130.   DirNamePtr  = POINTER TO DirName;
  131.  
  132.   FileReqFlags = (listFunc,gEventFunc,addGadFunc,newWindFunc,newIDCMP,
  133.                   doColor,doMsgFunc,doWildFunc);
  134.   FileReqFlagSet = SET OF FileReqFlags;
  135.   FileReqFunc = PROCEDURE(ADDRESS,LONGCARD): LONGINT;
  136. (* I've changed the parameter's order 'cause I heard that M2-arguments
  137.    are put on the stack in this order. I didn't test this yet! *)
  138.  
  139.   FileRequesterPtr = POINTER TO FileRequester;
  140.   FileRequester = RECORD
  141.     hail: STRPTR;                (* Hailing text                     *)
  142.     ddef: FileNamePtr;           (* Filename array (FCHARS+1)        *)
  143.     ddir: DirNamePtr;            (* Directory array (DSIZE+1)        *)
  144.     wind: WindowPtr;             (* Window requesting or NULL        *)
  145.     funcFlags: FileReqFlagSet;   (* Control. See above.              *)
  146.     reserved1: UByte;            (* Set this to 0                    *)
  147.     function: FileReqFunc;       (* Your function, see btdef's       *)
  148.     reserved2: LONGINT;          (* reserved                         *)
  149.   END;
  150.  
  151. (*------  Structures and constants used by the wildcard routines  ------*)
  152.  
  153. CONST
  154.   pAny        =  80H;
  155.   pSingle     =  81H;
  156.   pOrStart    =  82H;
  157.   pOrNext     =  83H;
  158.   pOrEnd      =  84H;
  159.   pTag        =  85H;
  160.   pTagEnd     =  86H;
  161.   pNotClass   =  87H;
  162.   pClass      =  88H;
  163.   pRepBeg     =  89H;
  164.   pReqEnd     =  8AH;
  165.  
  166.   complexBit  =  1; (* status bits *)
  167.   examineBit  =  2;
  168.  
  169.   errorBufferOverflow = 303; (* Returned by FindFirst() and FindNext(); *)
  170.   errorInternal =  999;
  171.   errorBreak    =  304;
  172.  
  173.   bufSize       =  200;
  174.   dosTRUE       =  0;
  175.   dosFALSE      =  -1;
  176.   maxFName      =  200;
  177.  
  178.   stdAnchorSize = 256;
  179.  
  180. TYPE
  181.   AnchorPtr = POINTER TO Anchor;
  182.   AnchorPathPtr = POINTER TO AnchorPath;
  183.  
  184.   AnchorPath = RECORD (* this is used by FindFirst/FindNext *)
  185.     base: AnchorPtr;
  186.     last: AnchorPtr;
  187.     breakBits: LONGSET;
  188.     foundBreak: LONGSET;
  189.     length: LONGCARD;  (* set this to 0 *)
  190.     info: FileInfoBlock;
  191.   END;
  192.  
  193.   StdAnchorPathPtr = POINTER TO StdAnchorPath;
  194.   StdAnchorPath = RECORD
  195.     anchor: AnchorPath;  (* set anchor.length to stdAnchorSize *)
  196.     buffer: ARRAY[0..stdAnchorSize-1] OF CHAR;
  197.   END;
  198.  
  199.   Anchor = RECORD
  200.     next: AnchorPtr;
  201.     pred: AnchorPtr;
  202.     lock: FileLockPtr;
  203.     info: FileInfoBlockPtr;
  204.     status: LONGSET;  (* see bits above *)
  205.     CASE : CARDINAL OF
  206.       0: text: INTEGER; |
  207.       1: actual: ARRAY[0..1] OF Byte; |
  208.     END;
  209.   END;
  210.  
  211. (*------  Structure used by AddDANode etc.:  ------*)
  212.  
  213.   DirEntryTypes   = (devices,diskonly,volumes,dirs,det4,det5);
  214.   DirEntryTypeSet = SET OF DirEntryTypes;
  215.  
  216.   DirectoryEntryPtr = POINTER TO DirectoryEntry;
  217.   DirectoryEntry = RECORD
  218.     next: DirectoryEntryPtr;
  219.     type: DirEntryTypeSet;
  220.     flags: Byte;
  221.     name: ARRAY[0..255] OF CHAR; (* sorry, if your stuff gets longer! *)
  222.   END;
  223.  
  224. CONST
  225.   deFile      = DirEntryTypeSet{};          (*  0 *)
  226.   deDir       = DirEntryTypeSet{dirs};      (*  8 *)
  227.   deDevice    = DirEntryTypeSet{det4};      (* 16 *)
  228.   deVolume    = DirEntryTypeSet{dirs,det4}; (* 24 *)
  229.   deUnmounted = DirEntryTypeSet{det5};      (* 32 *)
  230.   deAssign    = DirEntryTypeSet{dirs,det5}; (* 40 *)
  231.  
  232. (*------  Resource Tracking:  ------*)
  233.  
  234.   trakAAMem   = 0;    (* Default generic (ArpAlloc) element  *)
  235.   trakLock    = 1;    (* File Lock                           *)
  236.   trakFile    = 2;    (* Opened File                         *)
  237.   trakWindow  = 3;    (* Window (see discussion)             *)
  238.   trakScreen  = 4;    (* Screen                              *)
  239.   trakLibrary = 5;    (* Opened library                      *)
  240.   trakDAMem   = 6;    (* Pointer to DosAllocMem block        *)
  241.   trakMemList = 7;    (* Exec Memlist                        *)
  242.   trakSegList = 8;    (* Program Segment List                *)
  243.   trakResList = 9;    (* ARP (nested) ResList                *)
  244.   trakMem     = 10;   (* Memory ptr/length                   *)
  245.   trakGeneric = 11;   (* Generic Element                     *)
  246.   trakDAList  = 12;   (* DAlist ( as used by file request )  *)
  247.   trakAnchor  = 13;   (* Anchor chain                        *)
  248.   trakMax     = 13;   (* Anything else is tossed.            *)
  249.  
  250. TYPE
  251.   ArpResListPtr = POINTER TO ArpResList;
  252.   ArpResList = RECORD
  253.     node: MinNode;      (* line these together *)
  254.     taskID: TaskPtr;
  255.     firstItem: MinList;
  256.     link: ArpResListPtr;   (* for temp removal from task rlist *)
  257.   END;
  258.  
  259.   TrackedResPtr = POINTER TO TrackedRes;
  260.   TrackedRes = RECORD
  261.     node: MinNode;
  262.     flags: Byte;
  263.     lock: Byte;
  264.     id: INTEGER;          (* see above *)
  265.     CASE :INTEGER OF
  266.       0:resource: ADDRESS;
  267.         value: LONGINT; |
  268.       1:function: PROC;
  269.         window2: WindowPtr; |
  270.     END;
  271.     user1 : ADDRESS;           (* A pointer you can use yourself    *)
  272.     user2 : LONGCARD;          (* A long you can use yourself       *)
  273.   END;
  274.  
  275.   DefaultTrackerPtr = POINTER TO DefaultTracker;
  276.   DefaultTracker = RECORD
  277.     CASE : CARDINAL OF
  278.       |0: resource : ADDRESS;   (* Whatever *)
  279.       |1: value    : LONGCARD;  (* For use during TrakGeneric    *)
  280.     END;
  281.     CASE : CARDINAL OF
  282.       |0: function : PROC;      (* Function to call for TrakGeneric *)
  283.       |1: window2  : WindowPtr; (* For TrakWindow                *)
  284.     END;
  285.     user1 : ADDRESS;           (* A pointer you can use yourself *)
  286.     user2 : LONGCARD;          (* A long you can use yourself    *)
  287.   END;
  288.  
  289. CONST
  290.   trbUnLink = 7;             (* free node bit *)
  291.   trbReloc  = 6;             (* This element may be relocated *)
  292.   trbMoved  = 5;             (* Item moved *)
  293.   trvUnLink = SHIFT(1,trbUnLink);
  294.   trvReloc  = SHIFT(1,trbReloc);
  295.  
  296. (*------  Errors returned by SyncRun() and ASyncRun():  ------*)
  297.  
  298.   prbSAVEIO      = 0;      (* Don't free/check file handles on exit *)
  299.   prbCLOSESPLAT  = 1;      (* Close Splat file, must request explicitly *)
  300.   prbNOCLI       = 2;      (* Don't create a CLI process *)
  301.   prbINTERACTIVE = 3;      (* This should be interactive *)
  302.   prbCODE        = 4;      (* Dangerous yet enticing *)
  303.   prbSTDIO       = 5;      (* Do the stdio thing, splat = CON:Filename *)
  304.  
  305.   prfSAVEIO      = SHIFT(1,0);
  306.   prfCLOSESPLAT  = SHIFT(1,1);
  307.   prfNOCLI       = SHIFT(1,2);
  308.   prfINTERACTIVE = SHIFT(1,3);
  309.   prfCODE        = SHIFT(1,4);
  310.   prfSTDIO       = SHIFT(1,5);
  311.  
  312.   prNoFile   = -1;   (* Could not LoadSeg() the file         *)
  313.   prNoMem    = -2;   (* No memory for something              *)
  314.   prNoCLI    = -3;   (* Caller must be CLI (SyncRun() only)  *)
  315.   prNoSlot   = -4;   (* No slot in TaskArray                 *)
  316.   prNoInput  = -5;   (* Could not open input file            *)
  317.   prNoOutput = -6;   (* Could not get output file            *)
  318.   prNoLock   = -7;   (* Could not get a lock                 *)
  319.   prArgErr   = -8;   (* Bad argument                         *)
  320.   prNoBCPL   = -9;   (* Bad program passed to ASyncRun()     *)
  321.   prBadLib   = -10;  (* Bad library version                  *)
  322.   prNoStdIO  = -11;  (* Couldn't get stdio handles.          *)
  323.  
  324.   errorNotCLI   = 400;  (* Program/function needs to be cli      *)
  325.   errorBadMagic = 401;  (* Invalid magic number for resident prg *)
  326.  
  327.   noCMD = "\n";
  328.  
  329. (*------  ZombieMsg (sent back on request by exiting process):  ------*)
  330.  
  331. TYPE
  332.   ZombieMsgPtr = POINTER TO ZombieMsg;
  333.   ZombieMsg = RECORD
  334.     message: Message;          (* You must init ReplyPort!!!!! *)
  335.     taskNum: LONGCARD;         (* Task ID                      *)
  336.     returnCode: LONGCARD;      (* Process's return code        *)
  337.     result2: LONGCARD;         (* System return code           *)
  338.     exitTime: Date;            (* Date stamp at time of exit   *)
  339.     userInfo: LONGCARD;        (* For whatever you wish.       *)
  340.   END;
  341.  
  342.   PCBFlags = (saveIO,           (* Don't release/check file handles         *)
  343.               closeSplat,       (* Close Splat file                         *)
  344.               noCLI,            (* Don't create a CLI process               *)
  345.               interactive,      (* This should be interactive, CLI's only   *)
  346.               code,             (* Actual code ADDRESS, be CAREFUL!         *)
  347.               stdIO);           (* Do the StdIO thing, Splat = CON:FileName *)
  348.   PCBFlagSet = SET OF PCBFlags;
  349.  
  350.   ProcessCtrlBlkPtr = POINTER TO PCB;
  351.   ProcessCtrlBlk = RECORD
  352.     stackSize: LONGCARD;         (* Stack for new process   *)
  353.     pri: Byte;                   (* Priority of new process *)
  354.     control: PCBFlagSet;         (* Control bits            *)
  355.     trapCode: ADDRESS;           (* Optional Trap Code      *)
  356.     input,output: FileHandlePtr; (* Optional stdin, stdout  *)
  357.     CASE : CARDINAL OF
  358.       0: splatFile: FileHandlePtr; | (* File to use for Open("*") *)
  359.       1: conName: ADDRESS;    |   (* or CON: filename             *)
  360.       2: console: ADDRESS;    |   (* Yippee for record variants!  *)
  361.     END;
  362.     loadedCode: ADDRESS;     (* If not null, will not load/unload code  *)
  363.     lastGasp: ZombieMsgPtr;  (* ReplyMsg() to be filled in by exit      *)
  364.     wbProcess: MsgPortPtr;   (* Valid when noerror and prbNOCLI is set *)
  365.   END;
  366.  
  367. (*------  Resident Program support:  ------*)
  368.  
  369. TYPE
  370.   ResidentPrgNodePtr = POINTER TO ResidentProgramNode;
  371.   ResidentPrgNode = RECORD
  372.     next: ResidentPrgNodePtr;
  373.     usage: LONGINT;  (* How many programs are currently using the code *)
  374.     checkSum: LONGCARD;
  375.     segment: BPTR;               (* Actual LoadSeg'ed segments         *)
  376.     name: ARRAY[0..255] OF CHAR; (* the names mem is allocated as needed !!! *)
  377.   END;
  378.  
  379.   ResidentProgramTag = RECORD
  380.     nextSeg: BPTR;       (* Provided by DOS at LoadSeg time.  *)
  381.     bra: CARDINAL;       (* Short branch to executable        *)
  382.     magic: CARDINAL;     (* Resident majik value              *)
  383.     stackSize: LONGCARD; (* min stack for this process        *)
  384.     dataSize: LONGCARD;  (* Data size to allocate if resident *)
  385.   END;
  386.  
  387.   ProcessMemoryPtr = POINTER TO ProcessMemory;
  388.   ProcessMemory = RECORD
  389.     node: Node;
  390.     num: CARDINAL; (* number of entries, 1 if no data 2 if data *)
  391.     stack: ADDRESS;
  392.     stackSize: LONGCARD;
  393.     data: ADDRESS;  (* pointer to data *)
  394.     dataSize: LONGCARD;
  395.   END;
  396.  
  397. CONST
  398.   residentMagic = 4AFCH;  (* same as RTC_MATCHWORD (trapf) *)
  399.   pMemName = "ARP_MEM";
  400.  
  401. (*------  String/Date Structures:  ------*)
  402.  
  403. TYPE
  404.   DateType = (amigaDOS,       (* dd-mmm-yy *)
  405.               international,  (* yy-mm-dd  *)
  406.               usa,            (* mm-dd-yy  *)
  407.               european);      (* dd-mm-yy  *)
  408.  
  409.   DateTimeFlags = (subst,    (* Substitute string such as "Today", ... *)
  410.                    future);  (* Monday, Tuesday ... refer to next week *)
  411.   DateTimeFlagSet = SET OF DateTimeFlags;
  412.  
  413.   DateTimePtr = POINTER TO DateTime;
  414.   DateTime = RECORD
  415.     stamp: Date;
  416.     format: DateType;
  417.     flags: DateTimeFlagSet;
  418.     day: STRPTR;
  419.     date: STRPTR;
  420.     time: STRPTR;
  421.   END;
  422.  
  423. CONST
  424.  lenDateString = 10H;
  425.  
  426. (*------  Procedures:  ------*)
  427.  
  428. PROCEDURE Open(name{1}: STRPTR;
  429.                accessMode{2}: LONGINT): FileHandlePtr;           CODE -30;
  430. PROCEDURE Close(file{1}: FileHandlePtr);                         CODE -36;
  431. PROCEDURE Read(file{1}: FileHandlePtr;
  432.                buffer{2}: ADDRESS;
  433.                length{3}: LONGINT): LONGINT;                     CODE -42;
  434. PROCEDURE Write(file{1}: FileHandlePtr;
  435.                 buffer{2}: ADDRESS;
  436.                 length{3}: LONGINT): LONGINT;                    CODE -48;
  437. PROCEDURE Input(): FileHandlePtr;                                CODE -54;
  438. PROCEDURE Output(): FileHandlePtr;                               CODE -60;
  439. PROCEDURE Seek(file{1}: FileHandlePtr;
  440.                position{2}: LONGINT;
  441.                mode{3}: LONGINT): LONGINT;                       CODE -66;
  442. PROCEDURE DeleteFile(name{1}: STRPTR): BOOLEAN;                  CODE -72;
  443. PROCEDURE Rename(oldName{1},newName{2}: STRPTR): BOOLEAN;        CODE -78;
  444. PROCEDURE Lock(name{1}: STRPTR;
  445.                accessMode{2}: LONGINT): FileLockPtr;             CODE -84;
  446. PROCEDURE UnLock(lock{1}: FileLockPtr);                          CODE -90;
  447. PROCEDURE DupLock(lock{1}: FileLockPtr): FileLockPtr;            CODE -96;
  448. PROCEDURE Examine(lock{1}: FileLockPtr;
  449.                   infoBlock{2}: FileInfoBlockPtr): BOOLEAN;      CODE -102;
  450. PROCEDURE ExNext(lock{1}: FileLockPtr;
  451.                  infoBlock{2}: FileInfoBlockPtr): BOOLEAN;       CODE -108;
  452. PROCEDURE Info(lock{1}: FileLockPtr;
  453.                parameterBlock{2}: InfoDataPtr): BOOLEAN;         CODE -114;
  454. PROCEDURE CreateDir(name{1}: STRPTR): FileLockPtr;               CODE -120;
  455. PROCEDURE CurrentDir(lock{1}: FileLockPtr): FileLockPtr;         CODE -126;
  456. PROCEDURE IoErr(): LONGINT;                                      CODE -132;
  457. PROCEDURE CreateProc(name{1}: STRPTR;
  458.                      pri{2}: LONGINT;
  459.                      segment{3}: BPTR;
  460.                      stackSize{4}: LONGINT): ProcessPtr;         CODE -138;
  461. PROCEDURE Exit(returnCode{1}: LONGINT);                          CODE -144;
  462. PROCEDURE LoadSeg(name{1}: STRPTR): BPTR;                        CODE -150;
  463. PROCEDURE UnLoadSeg(segment{1}: BPTR);                           CODE -156;
  464. PROCEDURE GetPacket(wait{1}: LONGINT): DosPacketPtr;             CODE -162;
  465. PROCEDURE QueuePacket(packet{1}: DosPacketPtr): LONGINT;         CODE -168;
  466. PROCEDURE DeviceProc(name{1}: STRPTR): ProcessPtr;               CODE -174;
  467. PROCEDURE SetComment(name{1},comment{2}: STRPTR): BOOLEAN;       CODE -180;
  468. PROCEDURE SetProtection(name{1}:STRPTR;
  469.                         mask{2}:LONGSET): BOOLEAN;               CODE -186;
  470. PROCEDURE DateStamp(v{1}: DatePtr);                              CODE -192;
  471. PROCEDURE Delay(ticks{1}: LONGINT);                              CODE -198;
  472. PROCEDURE WaitForChar(file{1}: FileHandlePtr;
  473.                       timeout{2}: LONGINT): BOOLEAN;             CODE -204;
  474. PROCEDURE ParentDir(lock{1}: FileLockPtr): FileLockPtr;          CODE -210;
  475. PROCEDURE IsInteractive(file{1}: FileHandlePtr): BOOLEAN;        CODE -216;
  476. PROCEDURE Execute(commandString{1}: STRPTR;
  477.                   input{2}: FileHandlePtr;
  478.                   output{3}: FileHandlePtr): LONGINT;            CODE -222;
  479.  
  480. (*------  New ARP Routines:  ------*)
  481.  
  482. PROCEDURE AddDADevs(dalist{8}: DirectoryEntryPtr;
  483.                     select{0}: DirEntryTypeSet): LONGINT;        CODE -516;
  484. PROCEDURE AddDANode(data{8}: ADDRESS;
  485.                     dalist{9}: DirectoryEntryPtr;
  486.                     length{0}: LONGINT;
  487.                     id{1}: DirEntryTypeSet): DirectoryEntryPtr;  CODE -510;
  488. PROCEDURE AddResidentPrg(segment{1}: BPTR;
  489.                          name{8}: STRPTR): ResidentPrgNodePtr;   CODE -582;
  490. PROCEDURE ArpAlloc(size{0}: LONGINT): ADDRESS;                   CODE -384;
  491. PROCEDURE ArpAllocMem(size{0}: LONGINT;
  492.                       reqs{1}: MemReqSet): ADDRESS;              CODE -390;
  493. PROCEDURE ArpDupLock(lock{1}: FileLockPtr): FileLockPtr;         CODE -402;
  494. PROCEDURE ArpExit(returncode{0}: LONGINT;
  495.                   fault{2}: LONGINT);                            CODE -378;
  496. PROCEDURE ArpLock(name{1}: STRPTR;
  497.                   accessMode{2}: LONGINT): FileLockPtr;          CODE -408;
  498. PROCEDURE ArpOpen(name{1}: STRPTR;
  499.                   accessmode{2}: LONGINT): FileHandlePtr;        CODE -396;
  500. PROCEDURE Assign(name{8}: STRPTR;
  501.                  phys{9}: STRPTR): AssignRes;                    CODE -336;
  502. PROCEDURE ASyncRun(command{8}: STRPTR;
  503.                    args{9}: STRPTR;
  504.                    pcb{10}: ProcessCtrlBlkPtr): LONGINT;         CODE -546;
  505. PROCEDURE Atol(string{8}: STRPTR): LONGINT;                      CODE -258;
  506. PROCEDURE BaseName(pathname{8}: STRPTR): STRPTR;                 CODE -630;
  507. PROCEDURE BtoCStr(cstring{8}: STRPTR;
  508.                   bstr{0}: BSTR;
  509.                   maxlength{1}: LONGINT): LONGINT;               CODE -354;
  510. PROCEDURE CheckAbort(func{9}: PROC): LONGSET;                    CODE -270;
  511. PROCEDURE CheckBreak(mask{1}: LONGSET;
  512.                      func{9}: PROC): LONGSET;                    CODE -276;
  513. PROCEDURE CheckSumPrg(node{1}: ResidentPrgNodePtr): LONGCARD;    CODE -618;
  514. PROCEDURE CloseWindowSafely(window{8}: WindowPtr;
  515.                             morewindows{9}: BOOLEAN);            CODE -300;
  516. PROCEDURE CompareLock(lock1{0},lock2{1}: FileLockPtr): LockComp; CODE -456;
  517. PROCEDURE CreatePort(name{8}: STRPTR;
  518.                      priority{0}: Byte): MsgPortPtr;             CODE -306;
  519. PROCEDURE CreateTaskResList(): ArpResListPtr;                    CODE -468;
  520. PROCEDURE CtoBStr(cstring{8}: STRPTR;
  521.                   bstr{0}: BSTR;
  522.                   maxlength{1}: LONGINT): LONGINT;               CODE -360;
  523. PROCEDURE DeletePort(port{9}: MsgPortPtr);                       CODE -312;
  524. PROCEDURE DosAllocMem(size{0}: LONGINT): ADDRESS;                CODE -342;
  525. PROCEDURE DosFreeMem(memBlk{9}: ADDRESS);                        CODE -348;
  526. PROCEDURE EscapeString(string{8}: STRPTR): LONGINT;              CODE -264;
  527. PROCEDURE FileRequest(filereq{8}: FileRequesterPtr): ADDRESS;    CODE -294;
  528. PROCEDURE FindCLI(tasknum{0}: LONGINT): ProcessPtr;              CODE -420;
  529. PROCEDURE FindFirst(pat{0}: STRPTR;
  530.                     chain{8}: AnchorPathPtr): LONGINT;           CODE -438;
  531. PROCEDURE FindNext(chain{8}: AnchorPathPtr): LONGINT;            CODE -444;
  532. PROCEDURE FindTaskResList(): ArpResListPtr;                      CODE -462;
  533. PROCEDURE FPrintf(file{0}: FileHandlePtr;
  534.                   string{8}: STRPTR;
  535.                   args{9}: ADDRESS): LONGINT;                    CODE -234;
  536. PROCEDURE FreeAccess(tracker{9}: TrackedResPtr);                 CODE -498;
  537. PROCEDURE FreeAnchorChain(chain{8}: AnchorPathPtr);              CODE -450;
  538. PROCEDURE FreeDAList(dalist{9}: ADDRESS);                        CODE -504;
  539. PROCEDURE FreeResList(freelist{9}: ADDRESS);                     CODE -474;
  540. PROCEDURE FreeTaskResList(): BOOLEAN;                            CODE -372;
  541. PROCEDURE FreeTrackeItem(item{9}: TrackedResPtr);                CODE -480;
  542. PROCEDURE GADS(cmdLine{8}: ADDRESS;
  543.                cmdLen{0}: LONGINT;
  544.                help{9}: STRPTR;
  545.                argarray{10}: ADDRESS;
  546.                tplate{11}: STRPTR): LONGINT;                     CODE -252;
  547. PROCEDURE GetAccess(tracker{9}: TrackedResPtr): TrackedResPtr;   CODE -492;
  548. PROCEDURE GetDevInfo(devinfo{10}: DeviceListPtr): DeviceListPtr; CODE -366;
  549. PROCEDURE GetEnv(string{8}: STRPTR;
  550.                  buffer{9}: ADDRESS;
  551.                  size{0}: LONGINT): STRPTR;                      CODE -282;
  552. PROCEDURE GetTracker(id{9}: LONGINT): DefaultTrackerPtr;         CODE -486;
  553. PROCEDURE InitStdPacket(action{0}: LONGINT;
  554.                         args{8}: ADDRESS;
  555.                         packet{9}: ADDRESS;
  556.                         replyport{10}: MsgPortPtr);              CODE -324;
  557. PROCEDURE LDiv(dividend{0},divisor{1}: LONGINT): LONGINT;        CODE -606;
  558. PROCEDURE LMod(dividend{0},divisor{1}: LONGINT): LONGINT;        CODE -612;
  559. PROCEDURE LMult(num1{0},num2{1}: LONGINT): LONGINT;              CODE -600;
  560. PROCEDURE LoadPrg(name{1}: STRPTR): BPTR;                        CODE -552;
  561. PROCEDURE ObtainResidentPrg(name{8}: STRPTR): ResidentPrgNodePtr;CODE -576;
  562. PROCEDURE PathName(lock{0}: FileLockPtr;
  563.                    dest{8}: STRPTR;
  564.                    numberNames{1}: LONGINT): LONGINT;            CODE -330;
  565. PROCEDURE PatternMatch(pat{8}: STRPTR;
  566.                        str{9}: STRPTR): BOOLEAN;                 CODE -432;
  567. PROCEDURE PreParse(source{8}: STRPTR;
  568.                    dest{9}: STRPTR): BOOLEAN;                    CODE -558;
  569. PROCEDURE Printf(string{8}: STRPTR;
  570.                  args{9}: ADDRESS): LONGINT;                     CODE -228;
  571. PROCEDURE Puts(string{9}: STRPTR): LONGINT;                      CODE -240;
  572. PROCEDURE QSort(baseptr{8}: ADDRESS;
  573.                 regionsize{0}: LONGINT;
  574.                 bytesize{1}: LONGINT;
  575.                 userfunction{9}: PROC): BOOLEAN;                 CODE -426;
  576. PROCEDURE ReadLine(buffer{8}: ADDRESS): LONGINT;                 CODE -246;
  577. PROCEDURE ReleaseResidentPrg(segment{1}: ADDRESS):
  578.                                       ResidentPrgNodePtr;        CODE -636;
  579. PROCEDURE RemResidentPrg(name{8}: STRPTR): LONGCARD;             CODE -588;
  580. PROCEDURE RListAlloc(reslist{8}: ArpResListPtr;
  581.                      size{0}: LONGINT): ADDRESS;                 CODE -414;
  582. PROCEDURE SendPacket(action{0}: LONGINT;
  583.                      args{8}: ADDRESS;
  584.                      handler{9}: MsgPortPtr): LONGINT;           CODE -318;
  585. PROCEDURE SetEnv(string{8}: STRPTR;
  586.                  buffer{9}: ADDRESS): BOOLEAN;                   CODE -288;
  587. PROCEDURE StampToStr(datetime{8}: DateTimePtr): BOOLEAN;         CODE -564;
  588. PROCEDURE Strcmp(s1{8},s2{9}: STRPTR): LONGINT;                  CODE -522;
  589. PROCEDURE Strncmp(st{8},s2{9}: STRPTR;
  590.                   n{0}: LONGINT): LONGINT;                       CODE -528;
  591. PROCEDURE StrToStamp(datetime{8}: DateTimePtr): BOOLEAN;         CODE -570;
  592. PROCEDURE SyncRun(filename{8}: STRPTR;
  593.                   args{9}: STRPTR;
  594.                   input{0}: FileHandlePtr;
  595.                   output{1}: FileHandlePtr): LONGINT;            CODE -540;
  596. PROCEDURE TackOn(pathname{8},filename{9}: STRPTR);               CODE -624;
  597. PROCEDURE ToUpper(old{0}: CHAR): CHAR;                           CODE -534;
  598. PROCEDURE UnLoadPrg(segment{1}: BPTR);                           CODE -594;
  599.  
  600. END ARP.
  601.